home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_richcmp.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  15KB  |  457 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import unittest
  5. from test import test_support
  6. import operator
  7.  
  8. class Number:
  9.     
  10.     def __init__(self, x):
  11.         self.x = x
  12.  
  13.     
  14.     def __lt__(self, other):
  15.         return self.x < other
  16.  
  17.     
  18.     def __le__(self, other):
  19.         return self.x <= other
  20.  
  21.     
  22.     def __eq__(self, other):
  23.         return self.x == other
  24.  
  25.     
  26.     def __ne__(self, other):
  27.         return self.x != other
  28.  
  29.     
  30.     def __gt__(self, other):
  31.         return self.x > other
  32.  
  33.     
  34.     def __ge__(self, other):
  35.         return self.x >= other
  36.  
  37.     
  38.     def __cmp__(self, other):
  39.         raise test_support.TestFailed, 'Number.__cmp__() should not be called'
  40.  
  41.     
  42.     def __repr__(self):
  43.         return 'Number(%r)' % (self.x,)
  44.  
  45.  
  46.  
  47. class Vector:
  48.     
  49.     def __init__(self, data):
  50.         self.data = data
  51.  
  52.     
  53.     def __len__(self):
  54.         return len(self.data)
  55.  
  56.     
  57.     def __getitem__(self, i):
  58.         return self.data[i]
  59.  
  60.     
  61.     def __setitem__(self, i, v):
  62.         self.data[i] = v
  63.  
  64.     
  65.     def __hash__(self):
  66.         raise TypeError, 'Vectors cannot be hashed'
  67.  
  68.     
  69.     def __nonzero__(self):
  70.         raise TypeError, 'Vectors cannot be used in Boolean contexts'
  71.  
  72.     
  73.     def __cmp__(self, other):
  74.         raise test_support.TestFailed, 'Vector.__cmp__() should not be called'
  75.  
  76.     
  77.     def __repr__(self):
  78.         return 'Vector(%r)' % (self.data,)
  79.  
  80.     
  81.     def __lt__(self, other):
  82.         return []([ a < b for a, b in zip(self.data, self._Vector__cast(other)) ])
  83.  
  84.     
  85.     def __le__(self, other):
  86.         return []([ a <= b for a, b in zip(self.data, self._Vector__cast(other)) ])
  87.  
  88.     
  89.     def __eq__(self, other):
  90.         return []([ a == b for a, b in zip(self.data, self._Vector__cast(other)) ])
  91.  
  92.     
  93.     def __ne__(self, other):
  94.         return []([ a != b for a, b in zip(self.data, self._Vector__cast(other)) ])
  95.  
  96.     
  97.     def __gt__(self, other):
  98.         return []([ a > b for a, b in zip(self.data, self._Vector__cast(other)) ])
  99.  
  100.     
  101.     def __ge__(self, other):
  102.         return []([ a >= b for a, b in zip(self.data, self._Vector__cast(other)) ])
  103.  
  104.     
  105.     def __cast(self, other):
  106.         if isinstance(other, Vector):
  107.             other = other.data
  108.         
  109.         if len(self.data) != len(other):
  110.             raise ValueError, 'Cannot compare vectors of different length'
  111.         
  112.         return other
  113.  
  114.  
  115. opmap = {
  116.     'lt': ((lambda a, b: a < b), operator.lt, operator.__lt__),
  117.     'le': ((lambda a, b: a <= b), operator.le, operator.__le__),
  118.     'eq': ((lambda a, b: a == b), operator.eq, operator.__eq__),
  119.     'ne': ((lambda a, b: a != b), operator.ne, operator.__ne__),
  120.     'gt': ((lambda a, b: a > b), operator.gt, operator.__gt__),
  121.     'ge': ((lambda a, b: a >= b), operator.ge, operator.__ge__) }
  122.  
  123. class VectorTest(unittest.TestCase):
  124.     
  125.     def checkfail(self, error, opname, *args):
  126.         for op in opmap[opname]:
  127.             self.assertRaises(error, op, *args)
  128.         
  129.  
  130.     
  131.     def checkequal(self, opname, a, b, expres):
  132.         for op in opmap[opname]:
  133.             realres = op(a, b)
  134.             self.assertEqual(len(realres), len(expres))
  135.             for i in xrange(len(realres)):
  136.                 self.assert_(realres[i] is expres[i])
  137.             
  138.         
  139.  
  140.     
  141.     def test_mixed(self):
  142.         a = Vector(range(2))
  143.         b = Vector(range(3))
  144.         for opname in opmap:
  145.             self.checkfail(ValueError, opname, a, b)
  146.         
  147.         a = range(5)
  148.         b = 5 * [
  149.             2]
  150.         args = [
  151.             (a, Vector(b)),
  152.             (Vector(a), b),
  153.             (Vector(a), Vector(b))]
  154.         for a, b in args:
  155.             self.checkequal('lt', a, b, [
  156.                 True,
  157.                 True,
  158.                 False,
  159.                 False,
  160.                 False])
  161.             self.checkequal('le', a, b, [
  162.                 True,
  163.                 True,
  164.                 True,
  165.                 False,
  166.                 False])
  167.             self.checkequal('eq', a, b, [
  168.                 False,
  169.                 False,
  170.                 True,
  171.                 False,
  172.                 False])
  173.             self.checkequal('ne', a, b, [
  174.                 True,
  175.                 True,
  176.                 False,
  177.                 True,
  178.                 True])
  179.             self.checkequal('gt', a, b, [
  180.                 False,
  181.                 False,
  182.                 False,
  183.                 True,
  184.                 True])
  185.             self.checkequal('ge', a, b, [
  186.                 False,
  187.                 False,
  188.                 True,
  189.                 True,
  190.                 True])
  191.             for ops in opmap.itervalues():
  192.                 for op in ops:
  193.                     self.assertRaises(TypeError, bool, op(a, b))
  194.                 
  195.             
  196.         
  197.  
  198.  
  199.  
  200. class NumberTest(unittest.TestCase):
  201.     
  202.     def test_basic(self):
  203.         for a in xrange(3):
  204.             for b in xrange(3):
  205.                 for typea in (int, Number):
  206.                     for typeb in (int, Number):
  207.                         if typeb == typeb:
  208.                             pass
  209.                         elif typeb == int:
  210.                             continue
  211.                         
  212.                         ta = typea(a)
  213.                         tb = typeb(b)
  214.                         for ops in opmap.itervalues():
  215.                             for op in ops:
  216.                                 realoutcome = op(a, b)
  217.                                 testoutcome = op(ta, tb)
  218.                                 self.assertEqual(realoutcome, testoutcome)
  219.                             
  220.                         
  221.                     
  222.                 
  223.             
  224.         
  225.  
  226.     
  227.     def checkvalue(self, opname, a, b, expres):
  228.         for typea in (int, Number):
  229.             for typeb in (int, Number):
  230.                 ta = typea(a)
  231.                 tb = typeb(b)
  232.                 for op in opmap[opname]:
  233.                     realres = op(ta, tb)
  234.                     realres = getattr(realres, 'x', realres)
  235.                     self.assert_(realres is expres)
  236.                 
  237.             
  238.         
  239.  
  240.     
  241.     def test_values(self):
  242.         self.checkvalue('lt', 0, 0, False)
  243.         self.checkvalue('le', 0, 0, True)
  244.         self.checkvalue('eq', 0, 0, True)
  245.         self.checkvalue('ne', 0, 0, False)
  246.         self.checkvalue('gt', 0, 0, False)
  247.         self.checkvalue('ge', 0, 0, True)
  248.         self.checkvalue('lt', 0, 1, True)
  249.         self.checkvalue('le', 0, 1, True)
  250.         self.checkvalue('eq', 0, 1, False)
  251.         self.checkvalue('ne', 0, 1, True)
  252.         self.checkvalue('gt', 0, 1, False)
  253.         self.checkvalue('ge', 0, 1, False)
  254.         self.checkvalue('lt', 1, 0, False)
  255.         self.checkvalue('le', 1, 0, False)
  256.         self.checkvalue('eq', 1, 0, False)
  257.         self.checkvalue('ne', 1, 0, True)
  258.         self.checkvalue('gt', 1, 0, True)
  259.         self.checkvalue('ge', 1, 0, True)
  260.  
  261.  
  262.  
  263. class MiscTest(unittest.TestCase):
  264.     
  265.     def test_misbehavin(self):
  266.         
  267.         class Misb:
  268.             
  269.             def __lt__(self, other):
  270.                 return 0
  271.  
  272.             
  273.             def __gt__(self, other):
  274.                 return 0
  275.  
  276.             
  277.             def __eq__(self, other):
  278.                 return 0
  279.  
  280.             
  281.             def __le__(self, other):
  282.                 raise TestFailed, "This shouldn't happen"
  283.  
  284.             
  285.             def __ge__(self, other):
  286.                 raise TestFailed, "This shouldn't happen"
  287.  
  288.             
  289.             def __ne__(self, other):
  290.                 raise TestFailed, "This shouldn't happen"
  291.  
  292.             
  293.             def __cmp__(self, other):
  294.                 raise RuntimeError, 'expected'
  295.  
  296.  
  297.         a = Misb()
  298.         b = Misb()
  299.         self.assertEqual(a < b, 0)
  300.         self.assertEqual(a == b, 0)
  301.         self.assertEqual(a > b, 0)
  302.         self.assertRaises(RuntimeError, cmp, a, b)
  303.  
  304.     
  305.     def test_not(self):
  306.         import operator as operator
  307.         
  308.         class Exc:
  309.             pass
  310.  
  311.         
  312.         class Bad:
  313.             
  314.             def __nonzero__(self):
  315.                 raise Exc
  316.  
  317.  
  318.         
  319.         def do(bad):
  320.             not bad
  321.  
  322.         for func in (do, operator.not_):
  323.             self.assertRaises(Exc, func, Bad())
  324.         
  325.  
  326.     
  327.     def test_recursion(self):
  328.         UserList = UserList
  329.         import UserList
  330.         a = UserList()
  331.         b = UserList()
  332.         a.append(b)
  333.         b.append(a)
  334.         self.assertRaises(RuntimeError, operator.eq, a, b)
  335.         self.assertRaises(RuntimeError, operator.ne, a, b)
  336.         self.assertRaises(RuntimeError, operator.lt, a, b)
  337.         self.assertRaises(RuntimeError, operator.le, a, b)
  338.         self.assertRaises(RuntimeError, operator.gt, a, b)
  339.         self.assertRaises(RuntimeError, operator.ge, a, b)
  340.         b.append(17)
  341.         self.assert_(not (a == b))
  342.         self.assert_(a != b)
  343.         self.assertRaises(RuntimeError, operator.lt, a, b)
  344.         self.assertRaises(RuntimeError, operator.le, a, b)
  345.         self.assertRaises(RuntimeError, operator.gt, a, b)
  346.         self.assertRaises(RuntimeError, operator.ge, a, b)
  347.         a.append(17)
  348.         self.assertRaises(RuntimeError, operator.eq, a, b)
  349.         self.assertRaises(RuntimeError, operator.ne, a, b)
  350.         a.insert(0, 11)
  351.         b.insert(0, 12)
  352.         self.assert_(not (a == b))
  353.         self.assert_(a != b)
  354.         self.assert_(a < b)
  355.  
  356.  
  357.  
  358. class DictTest(unittest.TestCase):
  359.     
  360.     def test_dicts(self):
  361.         import random as random
  362.         imag1a = { }
  363.         for i in range(50):
  364.             imag1a[random.randrange(100) * (0.0+1.0j)] = random.randrange(100) * (0.0+1.0j)
  365.         
  366.         items = imag1a.items()
  367.         random.shuffle(items)
  368.         imag1b = { }
  369.         for k, v in items:
  370.             imag1b[k] = v
  371.         
  372.         imag2 = imag1b.copy()
  373.         imag2[k] = v + 1.0
  374.         self.assert_(imag1a == imag1a)
  375.         self.assert_(imag1a == imag1b)
  376.         self.assert_(imag2 == imag2)
  377.         self.assert_(imag1a != imag2)
  378.         for opname in ('lt', 'le', 'gt', 'ge'):
  379.             for op in opmap[opname]:
  380.                 self.assertRaises(TypeError, op, imag1a, imag2)
  381.             
  382.         
  383.  
  384.  
  385.  
  386. class ListTest(unittest.TestCase):
  387.     
  388.     def assertIs(self, a, b):
  389.         self.assert_(a is b)
  390.  
  391.     
  392.     def test_coverage(self):
  393.         x = [
  394.             42]
  395.         self.assertIs(x < x, False)
  396.         self.assertIs(x <= x, True)
  397.         self.assertIs(x == x, True)
  398.         self.assertIs(x != x, False)
  399.         self.assertIs(x > x, False)
  400.         self.assertIs(x >= x, True)
  401.         y = [
  402.             42,
  403.             42]
  404.         self.assertIs(x < y, True)
  405.         self.assertIs(x <= y, True)
  406.         self.assertIs(x == y, False)
  407.         self.assertIs(x != y, True)
  408.         self.assertIs(x > y, False)
  409.         self.assertIs(x >= y, False)
  410.  
  411.     
  412.     def test_badentry(self):
  413.         
  414.         class Exc:
  415.             pass
  416.  
  417.         
  418.         class Bad:
  419.             
  420.             def __eq__(self, other):
  421.                 raise Exc
  422.  
  423.  
  424.         x = [
  425.             Bad()]
  426.         y = [
  427.             Bad()]
  428.         for op in opmap['eq']:
  429.             self.assertRaises(Exc, op, x, y)
  430.         
  431.  
  432.     
  433.     def test_goodentry(self):
  434.         
  435.         class Good:
  436.             
  437.             def __lt__(self, other):
  438.                 return True
  439.  
  440.  
  441.         x = [
  442.             Good()]
  443.         y = [
  444.             Good()]
  445.         for op in opmap['lt']:
  446.             self.assertIs(op(x, y), True)
  447.         
  448.  
  449.  
  450.  
  451. def test_main():
  452.     test_support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
  453.  
  454. if __name__ == '__main__':
  455.     test_main()
  456.  
  457.